home *** CD-ROM | disk | FTP | other *** search
/ BCI NET 2 / BCI NET 2.iso / archives / programming / source / xdme_1.84_src.lha / XDME / include / prog-protos.h < prev    next >
Encoding:
Text File  |  1994-12-22  |  15.2 KB  |  331 lines
  1. Prototype const UBYTE * version;
  2. Prototype NOT_BLOCK_C_CONST Block     ActualBlock;
  3. Prototype ED * set_block_ep (ED * new_ed);
  4. Prototype UWORD set_block_type (UWORD type);
  5. Prototype UWORD set_block_flags (UWORD newflags, UWORD flagmask);
  6. Prototype Block * get_block (Block * buf);
  7. Prototype Block * set_block (Block *buf);
  8. Prototype void set_block_start (Line line, Column column);
  9. Prototype void set_block_end (Line line, Column column);
  10. Prototype void unblock (void);
  11. Prototype Column block_leftcolumn (Line);
  12. Prototype Column block_rightcolumn (Line);
  13. Prototype void block_normalize (void);
  14. Prototype UWORD is_inblock (Line line, Column col);
  15. Prototype BOOL IsBlockVisible (void);
  16. Prototype void displayblock (BOOL on);
  17. Prototype BOOL block_ok (void);
  18. Prototype char * block_to_string (void);
  19. Prototype ULONG            OpenRexx         (char *, const char *, __stkargs void (*do_res)(struct RexxMsg *), BPTR, BPTR);
  20. Prototype BOOL               CloseRexx        (void);
  21. Prototype long               LastRexxError        (void);
  22. Prototype struct RexxMsg     * BuildRexxMsg        (const char *, const long, char *, ...);
  23. Prototype BOOL               RemoveRexxMsg        (struct RexxMsg *);
  24. Prototype BOOL               PutRexxMsg        (char *, struct RexxMsg *);
  25. Prototype struct RexxMsg     * GetRexxMsg        (void);
  26. Prototype struct RexxMsg     * FetchRexxMsg        (void);
  27. Prototype BOOL               ReplyRexxMsg        (struct RexxMsg *, long, char *);
  28. Prototype long               SyncRexxCommand        (const char *, const char *, char *, long, char *, ...);
  29. Prototype __stkargs void       RexxMessageHandler   (struct RexxMsg *);
  30. Prototype void             * ChangeProcessMessage (__stkargs void (*new_func)(struct RexxMsg *));
  31. Prototype struct RexxCommand * SetRexxCommandTable  (struct RexxCommand *);
  32. Prototype long               ModifyRepCount        (long);
  33. Prototype BOOL               AttempCloseRexx        (void);
  34. Prototype void redraw_block (BOOL force, Line start_line, Column start_column, Line end_line, Column end_column);
  35. Prototype ULONG RexxMask;
  36. Prototype int foundcmd; /* control for implicit ARexx macro invocation     */
  37. Prototype int cmderr;    /* global command error flag for do_rexx()'s use */
  38. Prototype long do_rexx (const char * port, const char *fmt,...);
  39. Prototype char * get_rexx_result (void);
  40. Prototype void openrexx (void);
  41. Prototype void closerexx (void);
  42. Prototype long do_rxImplied (char * cmd,char * args);
  43. Prototype void extern_rexx_command (void);
  44. Prototype void check_stack (ED * ep);
  45. Prototype struct FileRequester     * FReq;
  46. Prototype struct ReqToolsBase     * ReqToolsBase;
  47. Prototype struct rtFileRequester * RFReq;
  48. Prototype char pattern[];
  49. Prototype int aslsave (void);
  50. Prototype void fixdirname (char * dir);
  51. Prototype void splitpath (char * name, char * file, char * dir);
  52. Prototype int reqsave (void);
  53. Prototype int getappname (char * buffer, int bsize);
  54. Prototype int saveit (const char * om);
  55. Prototype int tas_flag (char * what, int old, char * prefix);
  56. Prototype void loadconfig (ED * ep);
  57. Prototype LIST        DBase;
  58. Prototype ED      * Ep;
  59. Prototype struct Config default_config;
  60. Prototype struct GlobalFlags globalflags;
  61. Prototype long        Nsu;
  62. Prototype UBYTE     CtlC;
  63. Prototype UBYTE     Current[MAXLINELEN];
  64. Prototype UBYTE     Deline[MAXLINELEN];
  65. Prototype UBYTE     Space[32];
  66. Prototype Column    Clen;
  67. Prototype UBYTE   * Partial;
  68. Prototype UBYTE   * esc_partial;
  69. Prototype UBYTE   * String;
  70. Prototype UWORD     ColumnPos[MAXLINELEN];
  71. Prototype UWORD     RowPos[MAXROWS];
  72. Prototype UWORD     Xsize;
  73. Prototype UWORD     Ysize;
  74. Prototype UWORD     XTbase;
  75. Prototype UWORD     YTbase;
  76. Prototype UWORD     Lines;
  77. Prototype UWORD     Columns;
  78. Prototype UWORD     Xbase;
  79. Prototype UWORD     Ybase;
  80. Prototype UWORD     Xpixs;
  81. Prototype UWORD     Ypixs;
  82. Prototype UWORD     LineDistance;
  83. Prototype UBYTE   * av[];
  84. Prototype WORD        PageJump;
  85. Prototype UBYTE     RexxPortName[8];
  86. Prototype UBYTE     tmp_buffer[MAXLINELEN];
  87. Prototype UWORD     NumClicks;
  88. Prototype struct Library       * IconBase;
  89. Prototype struct Library       * AslBase;
  90. Prototype struct DosLibrary    * DOSBase;
  91. Prototype struct WBStartup     * Wbs;
  92. Prototype struct MsgPort  * Sharedport;
  93. Prototype char            MShowTitle;
  94. Prototype char            noadj;
  95. Prototype struct __XDMEArgs XDMEArgs;
  96. Prototype void PrintCWD (void);
  97. Prototype int main (int mac, char ** mav);
  98. Prototype void OptimizedRefresh (ED *);
  99. Prototype void exiterr (char * str);
  100. Prototype int breakcheck (void);
  101. Prototype void breakreset (void);
  102. Prototype void ops (char ** toolarray);
  103. Prototype BOOL loadfile (BPTR lock, char * name);
  104. Prototype int do_command (char * str);
  105. Prototype char * breakout (char ** ptr, char * quoted, char ** paux);
  106. Prototype ED * uninit_init (ED * ep);
  107. Prototype int setpen (Line line, Column column);
  108. Prototype WORD inversemode (int n);
  109. Prototype int text_init (ED * oldep, WIN * win, struct NewWindow * nw);
  110. Prototype BOOL text_switch (WIN * win);
  111. Prototype BOOL text_sync (void);
  112. Prototype BOOL text_adjust (BOOL force);
  113. Prototype void text_load (void);
  114. Prototype int text_colno (void);
  115. Prototype int text_lineno (void);
  116. Prototype int text_lines (void);
  117. Prototype int text_cols (void);
  118. Prototype int text_imode (void);
  119. Prototype int text_tabsize (void);
  120. Prototype UBYTE * text_name (void);
  121. Prototype void text_uninit (void);
  122. Prototype void text_cursor (int n);
  123. Prototype void text_position (int col, int row);
  124. Prototype void text_displayseg (int start, int lines);
  125. Prototype void text_redraw_cmdline (void);
  126. Prototype void text_redisplay (void);
  127. Prototype void text_redisplaycurrline (void);
  128. Prototype void text_write (UBYTE * str);
  129. Prototype void text_redrawblock (BOOL on);
  130. Prototype void redraw_text (Line start_line, Line end_line);
  131. Prototype void redraw_textlineseg (Line line, Column start_column, Column end_column);
  132. Prototype void redraw_lineseg (UBYTE * text, UWORD y, Column start_column, Column end_column);
  133. Prototype char icontitle_pattern[];
  134. Prototype void iconify (void);
  135. Prototype WIN * TOpenWindow (struct NewWindow * nw);
  136. Prototype WIN * opensharedwindow (struct NewWindow *nw);
  137. Prototype void closesharedwindow (WIN * win);
  138. Prototype int getyn (char * title, char * text, char * gads, ...);
  139. Prototype void show_title (char *);
  140. Prototype void title (char * fmt, ...);
  141. Prototype char title_pattern[];
  142. Prototype void format_string (char * dest, const char * fmt);
  143. Prototype void window_title (void);
  144. Prototype void set_window_params (void);
  145. Prototype char * geoskip (char * ptr, int * pval, int * psgn);
  146. Prototype void GeometryToNW (char * geo, struct NewWindow *nw);
  147. Prototype void rest_prop (ED * ep);
  148. Prototype void rem_prop (ED * ep);
  149. Prototype struct PropGadget * add_prop (struct Window * win);
  150. Prototype void free_prop (struct PropGadget * pg);
  151. Prototype void prop_adj (void);
  152. Prototype ULONG new_top (void);
  153. Prototype void error (char * fmt, ...);
  154. Prototype void warn (char * fmt, ...);
  155. Prototype char    * HistoBuff[];
  156. Prototype WORD      NumHistoLines;
  157. Prototype WORD      HistoLine;
  158. Prototype int get_char (ED * ep, struct pos * curr, int dir);
  159. Prototype int get_pong (int num);
  160. Prototype void escapecomlinemode (void);
  161. Prototype void markerkill (ED * ep);
  162. Prototype void swapmem (void *, void *, ULONG);
  163. Prototype void makemygadget (struct Gadget *gad);
  164. Prototype int firstns (char * str);
  165. Prototype int lastns (char * str);
  166. Prototype int wordlen (char * str);
  167. Prototype BOOL getpathto (BPTR lock, char * filename, char * buf);
  168. Prototype LINE allocline (long size);
  169. Prototype void freeline (LINE line);
  170. Prototype int detab (char * ibuf, char * obuf, int maxlen);
  171. Prototype int xefgets (FILE * fi, char * buf, int max);
  172. Prototype ED * finded (char * str, int doff);
  173. Prototype void mountrequest (int bool);
  174. Prototype FONT * GetFont (char * name, WORD  size);
  175. Prototype void movetocursor (void);
  176. Prototype int extend (ED * ep, int lines);
  177. Prototype int makeroom (int n);
  178. Prototype void freelist (LINE * list, int n);
  179. Prototype long lineflags (int line);
  180. Prototype void scroll_display (WORD dx, WORD dy, Column lc, Line tl, Column rc, Line bl);
  181. Prototype void ScrollAndUpdate (int dx, int dy);
  182. Prototype char * skip_whitespace (char * ptr);
  183. Prototype char is_number (char * str);
  184. Prototype char * getnextcomline (FILE* fi, int * lineno);
  185. Prototype char * fname (char * fullpath);
  186. Prototype BOOL switch_ed (ED * newed);
  187. Prototype void MakeRectVisible (WIN * win, UWORD minx, UWORD miny, UWORD maxx, UWORD maxy);
  188. Prototype int LINELEN (ED * ep, Line nr);
  189. Prototype ULONG ext_qualifiers;
  190. Prototype int  qualifier (char *);
  191. Prototype struct Library * ConsoleDevice;
  192. Prototype void keyboard_init (void);
  193. Prototype UBYTE* cqtoa (KEYSPEC *ks);
  194. Prototype BOOL get_codequal (const UBYTE *str, KEYSPEC *ks);
  195. Prototype TQUAL iqual2qual (ULONG qual, int blen, char * buf, int code);
  196. Prototype ULONG qual2iqual (TQUAL qual);
  197. Prototype BOOL a2iqual (const UBYTE *str, ULONG *piqual);
  198. Prototype UBYTE *iqual2a (ULONG iqual);
  199. Prototype void init_kb (void);
  200. Prototype UBYTE  CtoA (TCODE c);
  201. Prototype TQUAL CIgnoreQ (TCODE c);
  202. Prototype BOOL IsRawC (KEYSPEC *ks);
  203. Prototype int DeadKeyConvert (struct IntuiMessage * msg, UBYTE * buf, int bufsize, struct KeyMap * keymap);
  204. Prototype void keyctl (struct IntuiMessage *, int, ULONG);  /* PATCH_NULL [14 Feb 1993] : changed to void */
  205. Prototype int     loadkeys    (KEYTABLE * kt, FILE * fi, int * lineno);
  206. Prototype int     savekeys    (KEYTABLE * kt, FILE * fo);
  207. Prototype HASH * findhash    (KEYTABLE * kt, KEYSPEC *ks,       UBYTE *, BOOL *);
  208. Prototype APTR     keyspec2macro    (KEYTABLE * kt,              const UBYTE *);
  209. Prototype int     resethash    (KEYTABLE * kt);
  210. Prototype int     unmapkey    (KEYTABLE * kt, const UBYTE *key);
  211. Prototype int     mapkey     (KEYTABLE * kt, const UBYTE *key, const UBYTE *value, const UBYTE *help);
  212. Prototype int     remhash    (KEYTABLE * kt, KEYSPEC *ks);
  213. Prototype int     addhash    (KEYTABLE * kt, KEYSPEC *ks, const UBYTE *comm, const UBYTE *help);
  214. Prototype void     dealloc_hash    (KEYTABLE * kt);
  215. Prototype KEYTABLE * get_keytable    (char * name);
  216. Prototype KEYTABLE * new_keytable    (char * name, int defaults);
  217. Prototype void         delete_keytable (KEYTABLE * kt, int force);
  218. Prototype void         exit_keytables (void);
  219. Prototype char*keyspectomacro(char*);
  220. Prototype void *currenthash (void);
  221. Prototype APTR menu_cmd (struct IntuiMessage * im);
  222. Prototype void *active_menu;
  223. Prototype void        menuclear   (MENUSTRIP *ms);
  224. Prototype int        menudel     (MENUSTRIP *ms, char *tname);
  225. Prototype int        itemdel     (MENUSTRIP *ms, char *tname, char *iname);
  226. Prototype int        subdel        (MENUSTRIP *ms, char *tname, char *iname, char *sname);
  227. Prototype XITEM *    itemadd     (MENUSTRIP *ms, char *tname, char *iname,              char *macro, char *help, int check, char *scut);
  228. Prototype XITEM *    subadd        (MENUSTRIP *ms, char *tname, char *iname, char *sname, char *macro, char *help, int check, char *scut);
  229. Prototype int        loadmenus   (MENUSTRIP *ms, FILE *fi,     int *lineno);
  230. Prototype int        savemenus   (MENUSTRIP *ms, FILE *fo);
  231. Prototype int        chkitemcheck(MENUSTRIP *ms, char *tname, char *iname);
  232. Prototype int        chksubcheck (MENUSTRIP *ms, char *tname, char *iname, char *sname);
  233. Prototype int        setitemcheck(MENUSTRIP *ms, char *tname, char *iname,              int status);
  234. Prototype int        setsubcheck (MENUSTRIP *ms, char *tname, char *iname, char *sname, int status);
  235. Prototype APTR        menu2macro  (MENUSTRIP *ms, char *str);
  236. Prototype MENUSTRIP *get_menustrip    (char * name);
  237. Prototype MENUSTRIP *new_menustrip    (char * name, int defaults);
  238. Prototype void         delete_menustrip (MENUSTRIP * kt, int force);
  239. Prototype void         exit_menustrips (void);
  240. Prototype char*menutomacro  (char*);
  241. Prototype void    menuon         (MENUSTRIP * ms, struct Window * win);
  242. Prototype void    menuoff      (MENUSTRIP * ms, struct Window * win);
  243. Prototype void    menu_strip   (MENUSTRIP * ms, struct Window * Win);
  244. Prototype int    fixmenu      (MENUSTRIP * ms, struct Window * win);
  245. Prototype struct TextAttr  menufont_ta;
  246. Prototype struct TextFont *menufont;
  247. Prototype void *currentmenu  (void);
  248. Prototype struct Window *currentwindow(void);
  249. Prototype void verify_menufont (void);
  250. Prototype void      do_unnamedmathfunc(void);
  251. Prototype void      do_namedmathfunc  (void);
  252. Prototype void      do_infixmode        (void);
  253. Prototype void      do_swapV        (void);
  254. Prototype void clearbreaks (void);
  255. Prototype void m_write (char *);
  256. Prototype char *current_word (void);
  257. Prototype char *recent_word (void);
  258. Prototype APTR AllocFunc (long siz, long typ);
  259. Prototype void FreeFunc (APTR mem, long siz);
  260. Prototype void DeallocFunc (char * str);
  261. Prototype char * DupFunc (const char * str, long typ);
  262. Prototype VBASE *GetMVBase (void);
  263. Prototype int callmacro (MACRO*);
  264. Prototype MACRO *getmacro (char *name);
  265. Prototype int nummacroargs (MACRO *);
  266. Prototype UBYTE         *APIC_IconTitle;
  267. Prototype UBYTE         *APIC_IconFile;
  268. Prototype UBYTE         *APIC_ActionDblClick;
  269. Prototype UBYTE         *APIC_ActionDrop;
  270. Prototype ULONG          APIC_SigMask;
  271. Prototype void APIC_Control (void);
  272. Prototype int do_apicshow (void);
  273. Prototype int do_apichide (void);
  274. Prototype ULONG CMDSH_SigMask;
  275. Prototype UBYTE*CMDSH_FileName;
  276. Prototype UBYTE*CMDSH_Prompt;
  277. Prototype void    CMDSH_Control     (void);
  278. Prototype int    CMDSH_Print     (const char *, ULONG *);
  279. Prototype int do_closecmdshell (void);
  280. Prototype int do_opencmdshell (void);
  281. Prototype int do_cmdshelloutput (void);
  282. Prototype UBYTE * GetArg      (int);
  283. Prototype UBYTE * CommandName (void);
  284. Prototype void clear_record    (void);
  285. Prototype void start_recording    (void);
  286. Prototype void end_recording    (void);
  287. Prototype void replay_record    (void);
  288. Prototype void do_saverecord    (void);
  289. Prototype void add_record    (char * string);
  290. Prototype void do_simptr    (void);
  291. Prototype void VSTK_CloseProject (APTR prj);
  292. Prototype int SetLNode (UBYTE *name, UBYTE *value);
  293. Prototype UBYTE *GetLNode (UBYTE *name);
  294. Prototype char ReqString[];
  295. Prototype int is_Aborted (void);
  296. Prototype void set_Abortion (int val);
  297. Prototype void no_Memory (void);
  298. Prototype APTR active_window (void);
  299. Prototype void strtrans (char * str, const char *find, const char *rep);
  300. Prototype int std_writefile (int (*writefunc)(FILE *, APTR), APTR);
  301. Prototype int std_readfile (int (*readfunc)(FILE *, APTR), APTR);
  302. Prototype int buffered_do_command (const char *str);
  303. Prototype int NodeStringComparison (struct Node *n1, STRPTR str);
  304. Prototype int NodeNodeComparison (struct Node *n1, struct Node *n2);
  305. Prototype struct TextAttr GTB_Font;
  306. Prototype UBYTE      *GTB_Format;
  307. Prototype ULONG       GTB_SigMask;
  308. Prototype int GTB_Control (void);
  309. Prototype int     test_arg  (char*, int);
  310. Prototype char * GetFlag   (char*, char*, int, char*);
  311. Prototype char     SetFlag   (char*, char*, char*, int, char*);
  312. Prototype int     IsFlagSet (char*, int, int);
  313. Prototype int is_tflagset (int);
  314. Prototype int is_gflagset (int);
  315. Prototype char *GetTypedVar (const char *find, int *type);
  316. Prototype int SetTypedVar (const char *name, const char *value, int type);
  317. Prototype char *getvar (const char *find);
  318. Prototype void     DelAllVarsFromTree ( VBASE *base );
  319. Prototype void     DelVarFromTree     ( VBASE *base, UBYTE *name );
  320. Prototype UBYTE *GetVarFromTree     ( VBASE *base, UBYTE *name );
  321. Prototype void     SetVarIntoTree     ( VBASE *base, UBYTE *name, UBYTE *value );
  322. Prototype UBYTE *ltostr (long l);
  323. Prototype char *strrep (char *old, const char *new);
  324. Prototype char SPC_set (const char *name, const char *value);
  325. Prototype char *SPC_get (const char *name);
  326. Prototype char * GetRexxClip  (char *);
  327. Prototype void     SetRexxClip  (char *, char *);
  328. Prototype void * currentmsg;
  329. Prototype char * getrexxvar   (char * name);
  330. Prototype void     setrexxvar   (char * name, char * value);
  331.